home *** CD-ROM | disk | FTP | other *** search
/ CD ROM Paradise Collection 4 / CD ROM Paradise Collection 4 1995 Nov.iso / edit / yame.zip / YSAMPLES.DBT (.txt) < prev    next >
dBase/FoxBase/XBase/FoxPro Database File  |  1994-01-28  |  27KB  |  542 lines

  1. YSAMPLES
  2. TOPIC
  3. AUTHOR
  4. ARG_PRO
  5. ARG_CON
  6. NOTES
  7.  Round circles       J. Doe                                  These memos have been saved with a 57-character margin for YSAMPLE1.FMT                    Round circles       J. Doe                                  These memos have been saved with a 37-character margin for YSAMPLE2.FMT   
  8. Essential to the flexibility of YAME is its capability to 
  9. dynamically configure itself without leaving dBASE. This 
  10. is achieved with tiered parameters. When invoked, YAME 
  11. attempts to process four stages of parameters:
  12.     (1) Default
  13.     (2) .COM invocation
  14.     (3) YAMEPARM
  15.     (4) .BIN invocation
  16. When run as a .COM, YAME will go through stages 1, 2, and 
  17. 3; for .BIN invocation, stages 1, 3, and 4. Some examples 
  18. will make things clearer:
  19. Let's say that you want to run YAME as your external memo 
  20. editor, a .COM invocation. You want a margin of 50 for 
  21. most of your memo fields. The default word wrap margin is 
  22. 65 characters. You add the following WP line to your 
  23. CONFIG.DB file:
  24.     WP = Y /m50
  25. Every time you edit a memo, dBASE runs YAME. When YAME 
  26. starts, it sets its margin to the default, 65. It then 
  27. sees the parameter specified when it was run, a margin of 
  28. 50. That is the margin that is used.
  29. If you then want a margin of 70 for a particular memo, 
  30. you'll need to override the default margin of 65 and the 
  31. margin of 50 specified on the WP line of the CONFIG.DB 
  32. file. This is when YAMEPARM comes in. You CALL YAMEPARM 
  33. with parameters that you want:
  34.     call YAMEPARM with "/m70"
  35. The next time YAME runs, it will set its default margin, 
  36. then the margin of 50, and then see the parameter in 
  37. YAMEPARM and use that. If you had another memo with a 
  38. margin of 40, you'd:
  39.     call YAMEPARM with "/m40"
  40. and when you want to revert back to the WP parameters, 
  41. you'd:
  42.     call YAMEPARM
  43. Parameters set up through YAMEPARM will stay in effect 
  44. until different parameters are sent, or until you 
  45. uninstall YAMEPARM by CALLing it with no parameters.
  46. For a .BIN invocation, you'd use YAMEPARM to set your 
  47. personal defaults:
  48.     call YAMEPARM with "/m50"
  49. From then on, every time you CALL Y, YAME will first set 
  50. the margin to its default, 65, then see the margin in 
  51. YAMEPARM and use that. If you then wanted a margin of 70, 
  52. you'd include the margin parameter in the CALL:
  53.     call Y with "/m70 MEMO_TMP.$DB"
  54. If you ever want to go back to your personal default of 
  55. 50, leave out the margin parameter in the CALL to YAME:
  56.     call Y with "MEMO_TMP.$DB"
  57. And if you ever want to use YAME's default of 65, you can
  58.     call YAMEPARM
  59. to clear your personal default as well.
  60. YAMEPARM and YAMEBUFF communicate with Y.COM by using one 
  61. of the User Interrupt Vectors (Int 60h - 66h). Some of 
  62. these vectors are used by other programs and drivers, but 
  63. there are usually a few available.
  64. YAMEPARM and YAMEBUFF each use their own vector, so if 
  65. both of them are LOADed and installed, they use two 
  66. vectors. If they are not uninstalled before they are 
  67. RELEASEd and/or you QUIT dBASE, those vectors will not be 
  68. cleared. Pretty soon, there will be no free vectors, and 
  69. YAMEPARM and YAMEBUFF will fail.
  70. Therefore, it is absolutely critical that you uninstall 
  71. YAMEPARM and YAMEBUFF by CALLing them with no parameters 
  72. before RELEASing them and/or QUITting dBASE. Again, IT IS 
  73. ABSOLUTELY CRITICAL THAT YOU UNINSTALL YAMEPARM AND 
  74. YAMEBUFF BY CALLING THEM WITH NO PARAMETERS BEFORE 
  75. RELEASING THEM AND/OR QUITTING DBASE.
  76. YAMEPARM will indicate successful installation by 
  77. changing the first letter of the parameter string to a 
  78. "T"; failure is indicated by an "F".  For example, the 
  79. sequence
  80.     cParm = "/@11,0,19,39 /bd"
  81.     call YAMEPARM with cParm
  82. will change the memory variable cParm to
  83.     "T@11,0,19,39 /bd"
  84. if YAMEPARM is installed successfully and
  85.     "F@11,0,19,39 /bd"
  86. if it is not. Once installed successfully, further CALLs 
  87. to YAMEPARM should return "T", until of course YAMEPARM 
  88. is RELEASEd or dBASE QUITs. Since the memory variable is 
  89. changed, the original character, usually a "/", must be 
  90. restored before using the parameter string again.
  91. Note that every time you pass parameters to YAMEPARM, 
  92. they stay memory resident. You do not have to CALL 
  93. YAMEPARM before every single memo. You only need to use 
  94. YAMEPARM when the parameters change.
  95. YAMEBUFF operates in a similar manner. You CALL YAMEBUFF 
  96. with the maximum file size you want to allow. This limit 
  97. is enforced by the YAME program, and does not affect the 
  98. amount of memory occupied by YAMEBUFF.BIN. YAMEBUFF.BIN 
  99. is almost 64 KB in size; most of it, 63.5 KB or 65024 
  100. bytes, is buffer space; the remainder is the YAMEBUFF 
  101. installation code. Even if you
  102.     call YAMEBUFF with 4000
  103. to keep the memo fields below 4 KB, YAMEBUFF will still 
  104. occupy 64 KB of memory. In these situations, you can use 
  105. the smaller buffer file, YAMEBUF8.BIN, which has 8 KB 
  106. (8192 bytes) of buffer space. YAMEBUF8 works exactly like 
  107. YAMEBUFF, except that the maximum maximum is only 8 KB, 
  108. not 63.5 KB. Do not have YAMEBUFF and YAMEBUF8 LOADed 
  109. simulataneously.
  110. YAMEBUFF (and YAMEBUF8) will return the amount of space 
  111. that was registered as the maximum allowable file size. 
  112. In most cases, this means that your parameter will be 
  113. returned unchanged. The exceptions are:
  114.     (1) You asked for more space than there was in the 
  115. .BIN, i.e. more than 65024 for YAMEBUFF and 8192 for 
  116. YAMEBUF8. In those cases, those limits will be registered 
  117. and returned.
  118.     (2) You asked for more than 65535 bytes. Don't do 
  119. that.
  120.     (3) YAMEBUFF was unable to install itself. In this 
  121. case, YAMEBUFF will return 0. You should verify that the 
  122. return value is greater than zero to make sure that 
  123. YAMEBUFF was installed before your try to edit something.
  124. If either YAMEPARM or YAMEBUFF return failure codes ("F" 
  125. and 0, respectively), this means that there were no 
  126. available vectors to hook into. This is because either 
  127. you've already got a ton of gizmos loaded in your system, 
  128. or, more likely, you forgot to uninstall YAMEPARM or 
  129. YAMEBUFF before RELEASing them and/or QUITting dBASE. 
  130. Remember that it is absolutely critical that you 
  131. uninstall YAMEPARM and YAMEBUFF by CALLing them with no 
  132. parameters before RELEASing them and/or QUITting dBASE.
  133. Essential to the flexibility of YAME 
  134. is its capability to dynamically 
  135. configure itself without leaving 
  136. dBASE. This is achieved with tiered 
  137. parameters. When invoked, YAME 
  138. attempts to process four stages of 
  139. parameters:
  140.     (1) Default
  141.     (2) .COM invocation
  142.     (3) YAMEPARM
  143.     (4) .BIN invocation
  144. When run as a .COM, YAME will go 
  145. through stages 1, 2, and 3; for .BIN 
  146. invocation, stages 1, 3, and 4. Some 
  147. examples will make things clearer:
  148. Let's say that you want to run YAME 
  149. as your external memo editor, a .COM 
  150. invocation. You want a margin of 50 
  151. for most of your memo fields. The 
  152. default word wrap margin is 65 
  153. characters. You add the following WP 
  154. line to your CONFIG.DB file:
  155.     WP = Y /m50
  156. Every time you edit a memo, dBASE 
  157. runs YAME. When YAME starts, it sets 
  158. its margin to the default, 65. It 
  159. then sees the parameter specified 
  160. when it was run, a margin of 50. That 
  161. is the margin that is used.
  162. If you then want a margin of 70 for a 
  163. particular memo, you'll need to 
  164. override the default margin of 65 and 
  165. the margin of 50 specified on the WP 
  166. line of the CONFIG.DB file. This is 
  167. when YAMEPARM comes in. You CALL 
  168. YAMEPARM with parameters that you 
  169. want:
  170.     call YAMEPARM with "/m70"
  171. The next time YAME runs, it will set 
  172. its default margin, then the margin 
  173. of 50, and then see the parameter in 
  174. YAMEPARM and use that. If you had 
  175. another memo with a margin of 40, 
  176. you'd:
  177.     call YAMEPARM with "/m40"
  178. and when you want to revert back to 
  179. the WP parameters, you'd:
  180.     call YAMEPARM
  181. Parameters set up through YAMEPARM 
  182. will stay in effect until different 
  183. parameters are sent, or until you 
  184. uninstall YAMEPARM by CALLing it with 
  185. no parameters.
  186. For a .BIN invocation, you'd use 
  187. YAMEPARM to set your personal 
  188. defaults:
  189.     call YAMEPARM with "/m50"
  190. From then on, every time you CALL Y, 
  191. YAME will first set the margin to its 
  192. default, 65, then see the margin in 
  193. YAMEPARM and use that. If you then 
  194. wanted a margin of 70, you'd include 
  195. the margin parameter in the CALL:
  196.     call Y with "/m70 MEMO_TMP.$DB"
  197. If you ever want to go back to your 
  198. personal default of 50, leave out the 
  199. margin parameter in the CALL to YAME:
  200.     call Y with "MEMO_TMP.$DB"
  201. And if you ever want to use YAME's 
  202. default of 65, you can
  203.     call YAMEPARM
  204. to clear your personal default as 
  205. well.
  206. YAMEPARM and YAMEBUFF communicate 
  207. with Y.COM by using one of the User 
  208. Interrupt Vectors (Int 60h - 66h). 
  209. Some of these vectors are used by 
  210. other programs and drivers, but there 
  211. are usually a few available.
  212. YAMEPARM and YAMEBUFF each use their 
  213. own vector, so if both of them are 
  214. LOADed and installed, they use two 
  215. vectors. If they are not uninstalled 
  216. before they are RELEASEd and/or you 
  217. QUIT dBASE, those vectors will not be 
  218. cleared. Pretty soon, there will be 
  219. no free vectors, and YAMEPARM and 
  220. YAMEBUFF will fail.
  221. Therefore, it is absolutely critical 
  222. that you uninstall YAMEPARM and 
  223. YAMEBUFF by CALLing them with no 
  224. parameters before RELEASing them 
  225. and/or QUITting dBASE. Again, IT IS 
  226. ABSOLUTELY CRITICAL THAT YOU 
  227. UNINSTALL YAMEPARM AND YAMEBUFF BY 
  228. CALLING THEM WITH NO PARAMETERS 
  229. BEFORE RELEASING THEM AND/OR QUITTING 
  230. DBASE.
  231. YAMEPARM will indicate successful 
  232. installation by changing the first 
  233. letter of the parameter string to a 
  234. "T"; failure is indicated by an "F".  
  235. For example, the sequence
  236.     cParm = "/@11,0,19,39 /bd"
  237.     call YAMEPARM with cParm
  238. will change the memory variable cParm 
  239.     "T@11,0,19,39 /bd"
  240. if YAMEPARM is installed successfully 
  241.     "F@11,0,19,39 /bd"
  242. if it is not. Once installed 
  243. successfully, further CALLs to 
  244. YAMEPARM should return "T", until of 
  245. course YAMEPARM is RELEASEd or dBASE 
  246. QUITs. Since the memory variable is 
  247. changed, the original character, 
  248. usually a "/", must be restored 
  249. before using the parameter string 
  250. again.
  251. Note that every time you pass 
  252. parameters to YAMEPARM, they stay 
  253. memory resident. You do not have to 
  254. CALL YAMEPARM before every single 
  255. memo. You only need to use YAMEPARM 
  256. when the parameters change.
  257. YAMEBUFF operates in a similar 
  258. manner. You CALL YAMEBUFF with the 
  259. maximum file size you want to allow. 
  260. This limit is enforced by the YAME 
  261. program, and does not affect the 
  262. amount of memory occupied by 
  263. YAMEBUFF.BIN. YAMEBUFF.BIN is almost 
  264. 64 KB in size; most of it, 63.5 KB or 
  265. 65024 bytes, is buffer space; the 
  266. remainder is the YAMEBUFF 
  267. installation code. Even if you
  268.     call YAMEBUFF with 4000
  269. to keep the memo fields below 4 KB, 
  270. YAMEBUFF will still occupy 64 KB of 
  271. memory. In these situations, you can 
  272. use the smaller buffer file, 
  273. YAMEBUF8.BIN, which has 8 KB (8192 
  274. bytes) of buffer space. YAMEBUF8 
  275. works exactly like YAMEBUFF, except 
  276. that the maximum maximum is only 8 
  277. KB, not 63.5 KB. Do not have YAMEBUFF 
  278. and YAMEBUF8 LOADed simulataneously.
  279. YAMEBUFF (and YAMEBUF8) will return 
  280. the amount of space that was 
  281. registered as the maximum allowable 
  282. file size. In most cases, this means 
  283. that your parameter will be returned 
  284. unchanged. The exceptions are:
  285.     (1) You asked for more space than 
  286. there was in the .BIN, i.e. more than 
  287. 65024 for YAMEBUFF and 8192 for 
  288. YAMEBUF8. In those cases, those 
  289. limits will be registered and 
  290. returned.
  291.     (2) You asked for more than 65535 
  292. bytes. Don't do that.
  293.     (3) YAMEBUFF was unable to 
  294. install itself. In this case, 
  295. YAMEBUFF will return 0. You should 
  296. verify that the return value is 
  297. greater than zero to make sure that 
  298. YAMEBUFF was installed before your 
  299. try to edit something.
  300. If either YAMEPARM or YAMEBUFF return 
  301. failure codes ("F" and 0, 
  302. respectively), this means that there 
  303. were no available vectors to hook 
  304. into. This is because either you've 
  305. already got a ton of gizmos loaded in 
  306. your system, or, more likely, you 
  307. forgot to uninstall YAMEPARM or 
  308. YAMEBUFF before RELEASing them and/or 
  309. QUITting dBASE. Remember that it is 
  310. absolutely critical that you 
  311. uninstall YAMEPARM and YAMEBUFF by 
  312. CALLing them with no parameters 
  313. before RELEASing them and/or QUITting 
  314. dBASE.
  315. Essential to the flexibility of YAME is its capability to dynamically configure itself without leaving dBASE. This is achieved with tiered parameters. When invoked, YAME attempts to process four stages of parameters:
  316.     (1) Default
  317.     (2) .COM invocation
  318.     (3) YAMEPARM
  319.     (4) .BIN invocation
  320. When run as a .COM, YAME will go through stages 1, 2, and 3; for .BIN invocation, stages 1, 3, and 4. Some examples will make things clearer:
  321. Let's say that you want to run YAME as your external memo editor, a .COM invocation. You want a margin of 50 for most of your memo fields. The default word wrap margin is 65 characters. You add the following WP line to your CONFIG.DB file:
  322.     WP = Y /m50
  323. Every time you edit a memo, dBASE runs YAME. When YAME starts, it sets its margin to the default, 65. It then sees the parameter specified when it was run, a margin of 50. That is the margin that is used.
  324. If you then want a margin of 70 for a particular memo, you'll need to override the default margin of 65 and the margin of 50 specified on the WP line of the CONFIG.DB file. This is when YAMEPARM comes in. You CALL YAMEPARM with parameters that you want:
  325.     call YAMEPARM with "/m70"
  326. The next time YAME runs, it will set its default margin, then the margin of 50, and then see the parameter in YAMEPARM and use that. If you had another memo with a margin of 40, you'd:
  327.     call YAMEPARM with "/m40"
  328. and when you want to revert back to the WP parameters, you'd:
  329.     call YAMEPARM
  330. Parameters set up through YAMEPARM will stay in effect until different parameters are sent, or until you uninstall YAMEPARM by CALLing it with no parameters.
  331. For a .BIN invocation, you'd use YAMEPARM to set your personal defaults:
  332.     call YAMEPARM with "/m50"
  333. From then on, every time you CALL Y, YAME will first set the margin to its default, 65, then see the margin in YAMEPARM and use that. If you then wanted a margin of 70, you'd include the margin parameter in the CALL:
  334.     call Y with "/m70 MEMO_TMP.$DB"
  335. If you ever want to go back to your personal default of 50, leave out the margin parameter in the CALL to YAME:
  336.     call Y with "MEMO_TMP.$DB"
  337. And if you ever want to use YAME's default of 65, you can
  338.     call YAMEPARM
  339. to clear your personal default as well.
  340. YAMEPARM and YAMEBUFF communicate with Y.COM by using one of the User Interrupt Vectors (Int 60h - 66h). Some of these vectors are used by other programs and drivers, but there are usually a few available.
  341. YAMEPARM and YAMEBUFF each use their own vector, so if both of them are LOADed and installed, they use two vectors. If they are not uninstalled before they are RELEASEd and/or you QUIT dBASE, those vectors will not be cleared. Pretty soon, there will be no free vectors, and YAMEPARM and YAMEBUFF will fail.
  342. Therefore, it is absolutely critical that you uninstall YAMEPARM and YAMEBUFF by CALLing them with no parameters before RELEASing them and/or QUITting dBASE. Again, IT IS ABSOLUTELY CRITICAL THAT YOU UNINSTALL YAMEPARM AND YAMEBUFF BY CALLING THEM WITH NO PARAMETERS BEFORE RELEASING THEM AND/OR QUITTING DBASE.
  343. YAMEPARM will indicate successful installation by changing the first letter of the parameter string to a "T"; failure is indicated by an "F".  For example, the sequence
  344.     cParm = "/@11,0,19,39 /bd"
  345.     call YAMEPARM with cParm
  346. will change the memory variable cParm to
  347.     "T@11,0,19,39 /bd"
  348. if YAMEPARM is installed successfully and
  349.     "F@11,0,19,39 /bd"
  350. if it is not. Once installed successfully, further CALLs to YAMEPARM should return "T", until of course YAMEPARM is RELEASEd or dBASE QUITs. Since the memory variable is changed, the original character, usually a "/", must be restored before using the parameter string again.
  351. Note that every time you pass parameters to YAMEPARM, they stay memory resident. You do not have to CALL YAMEPARM before every single memo. You only need to use YAMEPARM when the parameters change.
  352. YAMEBUFF operates in a similar manner. You CALL YAMEBUFF with the maximum file size you want to allow. This limit is enforced by the YAME program, and does not affect the amount of memory occupied by YAMEBUFF.BIN. YAMEBUFF.BIN is almost 64 KB in size; most of it, 63.5 KB or 65024 bytes, is buffer space; the remainder is the YAMEBUFF installation code. Even if you
  353.     call YAMEBUFF with 4000
  354. to keep the memo fields below 4 KB, YAMEBUFF will still occupy 64 KB of memory. In these situations, you can use the smaller buffer file, YAMEBUF8.BIN, which has 8 KB (8192 bytes) of buffer space. YAMEBUF8 works exactly like YAMEBUFF, except that the maximum maximum is only 8 KB, not 63.5 KB. Do not have YAMEBUFF and YAMEBUF8 LOADed simulataneously.
  355. YAMEBUFF (and YAMEBUF8) will return the amount of space that was registered as the maximum allowable file size. In most cases, this means that your parameter will be returned unchanged. The exceptions are:
  356.     (1) You asked for more space than there was in the .BIN, i.e. more than 65024 for YAMEBUFF and 8192 for YAMEBUF8. In those cases, those limits will be registered and returned.
  357.     (2) You asked for more than 65535 bytes. Don't do that.
  358.     (3) YAMEBUFF was unable to install itself. In this case, YAMEBUFF will return 0. You should verify that the return value is greater than zero to make sure that YAMEBUFF was installed before your try to edit something.
  359. If either YAMEPARM or YAMEBUFF return failure codes ("F" and 0, respectively), this means that there were no available vectors to hook into. This is because either you've already got a ton of gizmos loaded in your system, or, more likely, you forgot to uninstall YAMEPARM or YAMEBUFF before RELEASing them and/or QUITting dBASE. Remember that it is absolutely critical that you uninstall YAMEPARM and YAMEBUFF by CALLing them with no parameters before RELEASing them and/or QUITting dBASE.
  360. Essential to the flexibility of YAME 
  361. is its capability to dynamically 
  362. configure itself without leaving 
  363. dBASE. This is achieved with tiered 
  364. parameters. When invoked, YAME 
  365. attempts to process four stages of 
  366. parameters:
  367.     (1) Default
  368.     (2) .COM invocation
  369.     (3) YAMEPARM
  370.     (4) .BIN invocation
  371. When run as a .COM, YAME will go 
  372. through stages 1, 2, and 3; for .BIN 
  373. invocation, stages 1, 3, and 4. Some 
  374. examples will make things clearer:
  375. Let's say that you want to run YAME 
  376. as your external memo editor, a .COM 
  377. invocation. You want a margin of 50 
  378. for most of your memo fields. The 
  379. default word wrap margin is 65 
  380. characters. You add the following WP 
  381. line to your CONFIG.DB file:
  382.     WP = Y /m50
  383. Every time you edit a memo, dBASE 
  384. runs YAME. When YAME starts, it sets 
  385. its margin to the default, 65. It 
  386. then sees the parameter specified 
  387. when it was run, a margin of 50. That 
  388. is the margin that is used.
  389. If you then want a margin of 70 for a 
  390. particular memo, you'll need to 
  391. override the default margin of 65 and 
  392. the margin of 50 specified on the WP 
  393. line of the CONFIG.DB file. This is 
  394. when YAMEPARM comes in. You CALL 
  395. YAMEPARM with parameters that you 
  396. want:
  397.     call YAMEPARM with "/m70"
  398. The next time YAME runs, it will set 
  399. its default margin, then the margin 
  400. of 50, and then see the parameter in 
  401. YAMEPARM and use that. If you had 
  402. another memo with a margin of 40, 
  403. you'd:
  404.     call YAMEPARM with "/m40"
  405. and when you want to revert back to 
  406. the WP parameters, you'd:
  407.     call YAMEPARM
  408. Parameters set up through YAMEPARM 
  409. will stay in effect until different 
  410. parameters are sent, or until you 
  411. uninstall YAMEPARM by CALLing it with 
  412. no parameters.
  413. For a .BIN invocation, you'd use 
  414. YAMEPARM to set your personal 
  415. defaults:
  416.     call YAMEPARM with "/m50"
  417. From then on, every time you CALL Y, 
  418. YAME will first set the margin to its 
  419. default, 65, then see the margin in 
  420. YAMEPARM and use that. If you then 
  421. wanted a margin of 70, you'd include 
  422. the margin parameter in the CALL:
  423.     call Y with "/m70 MEMO_TMP.$DB"
  424. If you ever want to go back to your 
  425. personal default of 50, leave out the 
  426. margin parameter in the CALL to YAME:
  427.     call Y with "MEMO_TMP.$DB"
  428. And if you ever want to use YAME's 
  429. default of 65, you can
  430.     call YAMEPARM
  431. to clear your personal default as 
  432. well.
  433. YAMEPARM and YAMEBUFF communicate 
  434. with Y.COM by using one of the User 
  435. Interrupt Vectors (Int 60h - 66h). 
  436. Some of these vectors are used by 
  437. other programs and drivers, but there 
  438. are usually a few available.
  439. YAMEPARM and YAMEBUFF each use their 
  440. own vector, so if both of them are 
  441. LOADed and installed, they use two 
  442. vectors. If they are not uninstalled 
  443. before they are RELEASEd and/or you 
  444. QUIT dBASE, those vectors will not be 
  445. cleared. Pretty soon, there will be 
  446. no free vectors, and YAMEPARM and 
  447. YAMEBUFF will fail.
  448. Therefore, it is absolutely critical 
  449. that you uninstall YAMEPARM and 
  450. YAMEBUFF by CALLing them with no 
  451. parameters before RELEASing them 
  452. and/or QUITting dBASE. Again, IT IS 
  453. ABSOLUTELY CRITICAL THAT YOU 
  454. UNINSTALL YAMEPARM AND YAMEBUFF BY 
  455. CALLING THEM WITH NO PARAMETERS 
  456. BEFORE RELEASING THEM AND/OR QUITTING 
  457. DBASE.
  458. YAMEPARM will indicate successful 
  459. installation by changing the first 
  460. letter of the parameter string to a 
  461. "T"; failure is indicated by an "F".  
  462. For example, the sequence
  463.     cParm = "/@11,0,19,39 /bd"
  464.     call YAMEPARM with cParm
  465. will change the memory variable cParm 
  466.     "T@11,0,19,39 /bd"
  467. if YAMEPARM is installed successfully 
  468.     "F@11,0,19,39 /bd"
  469. if it is not. Once installed 
  470. successfully, further CALLs to 
  471. YAMEPARM should return "T", until of 
  472. course YAMEPARM is RELEASEd or dBASE 
  473. QUITs. Since the memory variable is 
  474. changed, the original character, 
  475. usually a "/", must be restored 
  476. before using the parameter string 
  477. again.
  478. Note that every time you pass 
  479. parameters to YAMEPARM, they stay 
  480. memory resident. You do not have to 
  481. CALL YAMEPARM before every single 
  482. memo. You only need to use YAMEPARM 
  483. when the parameters change.
  484. YAMEBUFF operates in a similar 
  485. manner. You CALL YAMEBUFF with the 
  486. maximum file size you want to allow. 
  487. This limit is enforced by the YAME 
  488. program, and does not affect the 
  489. amount of memory occupied by 
  490. YAMEBUFF.BIN. YAMEBUFF.BIN is almost 
  491. 64 KB in size; most of it, 63.5 KB or 
  492. 65024 bytes, is buffer space; the 
  493. remainder is the YAMEBUFF 
  494. installation code. Even if you
  495.     call YAMEBUFF with 4000
  496. to keep the memo fields below 4 KB, 
  497. YAMEBUFF will still occupy 64 KB of 
  498. memory. In these situations, you can 
  499. use the smaller buffer file, 
  500. YAMEBUF8.BIN, which has 8 KB (8192 
  501. bytes) of buffer space. YAMEBUF8 
  502. works exactly like YAMEBUFF, except 
  503. that the maximum maximum is only 8 
  504. KB, not 63.5 KB. Do not have YAMEBUFF 
  505. and YAMEBUF8 LOADed simulataneously.
  506. YAMEBUFF (and YAMEBUF8) will return 
  507. the amount of space that was 
  508. registered as the maximum allowable 
  509. file size. In most cases, this means 
  510. that your parameter will be returned 
  511. unchanged. The exceptions are:
  512.     (1) You asked for more space than 
  513. there was in the .BIN, i.e. more than 
  514. 65024 for YAMEBUFF and 8192 for 
  515. YAMEBUF8. In those cases, those 
  516. limits will be registered and 
  517. returned.
  518.     (2) You asked for more than 65535 
  519. bytes. Don't do that.
  520.     (3) YAMEBUFF was unable to 
  521. install itself. In this case, 
  522. YAMEBUFF will return 0. You should 
  523. verify that the return value is 
  524. greater than zero to make sure that 
  525. YAMEBUFF was installed before your 
  526. try to edit something.
  527. If either YAMEPARM or YAMEBUFF return 
  528. failure codes ("F" and 0, 
  529. respectively), this means that there 
  530. were no available vectors to hook 
  531. into. This is because either you've 
  532. already got a ton of gizmos loaded in 
  533. your system, or, more likely, you 
  534. forgot to uninstall YAMEPARM or 
  535. YAMEBUFF before RELEASing them and/or 
  536. QUITting dBASE. Remember that it is 
  537. absolutely critical that you 
  538. uninstall YAMEPARM and YAMEBUFF by 
  539. CALLing them with no parameters 
  540. before RELEASing them and/or QUITting 
  541. dBASE.
  542.